باز کردن قدرت موازی: نگاهی عمیق به حافظه مشترک چندپردازشی در پایتون

در دوران پردازنده‌های چند هسته‌ای، نوشتن نرم‌افزاری که بتواند وظایف را به صورت موازی انجام دهد، دیگر یک مهارت خاص نیست — بلکه برای ساخت برنامه‌های با کارایی بالا یک ضرورت است. ماژول multiprocessing پایتون ابزاری قدرتمند برای بهره‌برداری از این هسته‌ها است، اما با یک چالش اساسی همراه است: فرآیندها، بر اساس طراحی، حافظه را به اشتراک نمی‌گذارند. هر فرآیند در فضای حافظه ایزوله خود عمل می‌کند، که برای ایمنی و پایداری عالی است اما زمانی که نیاز به ارتباط یا به اشتراک‌گذاری داده‌ها دارند، مشکلی ایجاد می‌کند.

اینجاست که حافظه مشترک وارد عمل می‌شود. این حافظه مکانیزمی را برای فرآیندهای مختلف فراهم می‌کند تا به یک بلوک حافظه دسترسی یافته و آن را تغییر دهند، که امکان تبادل کارآمد داده‌ها و هماهنگی را فراهم می‌آورد. ماژول multiprocessing روش‌های مختلفی را برای دستیابی به این هدف ارائه می‌دهد، اما رایج‌ترین آنها اشیاء Value، Array و Manager چند منظوره هستند. درک تفاوت بین این ابزارها بسیار مهم است، زیرا انتخاب اشتباه می‌تواند منجر به گلوگاه‌های عملکردی یا کد بیش از حد پیچیده شود.

این راهنما به بررسی دقیق این سه مکانیزم، ارائه مثال‌های واضح و یک چارچوب عملی برای تصمیم‌گیری در مورد اینکه کدام یک برای مورد استفاده خاص شما مناسب است، خواهد پرداخت.

درک مدل حافظه در چندپردازشی

قبل از پرداختن به ابزارها، درک اینکه چرا به آنها نیاز داریم ضروری است. هنگامی که یک فرآیند جدید را با استفاده از multiprocessing ایجاد می‌کنید، سیستم عامل یک فضای حافظه کاملاً جداگانه برای آن اختصاص می‌دهد. این مفهوم، که به عنوان ایزوله‌سازی فرآیند شناخته می‌شود، به این معنی است که یک متغیر در یک فرآیند کاملاً مستقل از متغیری با همان نام در فرآیند دیگر است.

این یک تمایز کلیدی از چندنخی (multi-threading) است، جایی که نخ‌ها در یک فرآیند به طور پیش‌فرض حافظه را به اشتراک می‌گذارند. با این حال، در پایتون، Global Interpreter Lock (GIL) اغلب از دستیابی نخ‌ها به موازی‌سازی واقعی برای وظایف وابسته به CPU جلوگیری می‌کند و چندپردازشی را به انتخاب ارجح برای کارهای فشرده محاسباتی تبدیل می‌کند. معاوضه این است که ما باید به صراحت در مورد نحوه اشتراک‌گذاری داده‌ها بین فرآیندهای خود عمل کنیم.

روش ۱: ابزارهای اولیه ساده - `Value` و `Array`

multiprocessing.Value و multiprocessing.Array مستقیم‌ترین و کارآمدترین روش‌ها برای اشتراک‌گذاری داده‌ها هستند. آنها اساساً پوشش‌هایی برای انواع داده C سطح پایین هستند که در یک بلوک حافظه مشترک که توسط سیستم عامل مدیریت می‌شود، قرار دارند. این دسترسی مستقیم به حافظه همان چیزی است که آنها را به طرز باورنکردنی سریع می‌کند.

اشتراک‌گذاری یک قطعه داده واحد با `multiprocessing.Value`

همانطور که از نامش پیداست، Value برای اشتراک‌گذاری یک مقدار اولیه و واحد، مانند یک عدد صحیح، یک عدد اعشاری یا یک بولین استفاده می‌شود. هنگام ایجاد یک Value، باید نوع آن را با استفاده از یک کد نوع مربوط به انواع داده C مشخص کنید.

بیایید به مثالی نگاه کنیم که در آن چندین فرآیند یک شمارنده مشترک را افزایش می‌دهند.

            
import multiprocessing

def worker(shared_counter, lock):
    for _ in range(10000):
        # Use a lock to prevent race conditions
        with lock:
            shared_counter.value += 1

if __name__ == "__main__":
    # 'i' for signed integer, 0 is the initial value
    counter = multiprocessing.Value('i', 0)
    lock = multiprocessing.Lock()

    processes = []
    for _ in range(10):
        p = multiprocessing.Process(target=worker, args=(counter, lock))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

    print(f"Final counter value: {counter.value}")
    # Expected output: Final counter value: 100000

            

              
                Copy
              
            
          

نکات کلیدی:

• کدهای نوع: ما از 'i' برای یک عدد صحیح علامت‌دار استفاده کردیم. کدهای رایج دیگر شامل 'd' برای یک عدد اعشاری با دقت مضاعف و 'c' برای یک کاراکتر منفرد هستند.
• ویژگی .value: برای دسترسی یا تغییر داده‌های زیرین، باید از ویژگی .value استفاده کنید.
• همگام‌سازی دستی است: به استفاده از multiprocessing.Lock توجه کنید. بدون قفل، چندین فرآیند می‌توانند به طور همزمان مقدار شمارنده را بخوانند، آن را افزایش دهند و دوباره بنویسند، که منجر به شرایط رقابت (race condition) می‌شود که در آن برخی از افزایش‌ها از بین می‌روند. Value و Array هیچ همگام‌سازی خودکاری را ارائه نمی‌دهند؛ شما باید آن را خودتان مدیریت کنید.

اشتراک‌گذاری مجموعه‌ای از داده‌ها با `multiprocessing.Array`

Array مشابه Value عمل می‌کند اما به شما امکان می‌دهد یک آرایه با اندازه ثابت از یک نوع اولیه واحد را به اشتراک بگذارید. این برای اشتراک‌گذاری داده‌های عددی بسیار کارآمد است و آن را به یک عنصر اصلی در محاسبات علمی و با کارایی بالا تبدیل می‌کند.

            
import multiprocessing

def square_elements(shared_array, lock, start_index, end_index):
    for i in range(start_index, end_index):
        # A lock isn't strictly needed here if processes work on different indices,
        # but it's crucial if they might modify the same index.
        with lock:
            shared_array[i] = shared_array[i] * shared_array[i]

if __name__ == "__main__":
    # 'i' for signed integer, initialized with a list of values
    initial_data = list(range(10))
    shared_arr = multiprocessing.Array('i', initial_data)
    lock = multiprocessing.Lock()

    p1 = multiprocessing.Process(target=square_elements, args=(shared_arr, lock, 0, 5))
    p2 = multiprocessing.Process(target=square_elements, args=(shared_arr, lock, 5, 10))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print(f"Final array: {list(shared_arr)}")
    # Expected output: Final array: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

            

              
                Copy
              
            
          

نکات کلیدی:

• اندازه و نوع ثابت: پس از ایجاد، اندازه و نوع داده Array قابل تغییر نیست.
• نمایه‌گذاری مستقیم: می‌توانید با استفاده از نمایه‌گذاری استاندارد مانند لیست (به عنوان مثال، shared_arr[i]) به عناصر دسترسی یافته و آنها را تغییر دهید.
• نکته همگام‌سازی: در مثال بالا، از آنجایی که هر فرآیند روی یک بخش متمایز و غیر همپوشان از آرایه کار می‌کند، قفل ممکن است غیرضروری به نظر برسد. با این حال، اگر احتمال دارد که دو فرآیند به یک فهرست بنویسند، یا اگر یک فرآیند نیاز به خواندن یک وضعیت ثابت داشته باشد در حالی که دیگری در حال نوشتن است، قفل برای اطمینان از یکپارچگی داده‌ها کاملاً ضروری است.

مزایا و معایب `Value` و `Array`

• مزایا:
  • عملکرد بالا: سریع‌ترین راه برای اشتراک‌گذاری داده‌ها به دلیل حداقل سربار و دسترسی مستقیم به حافظه.
  • اشغال حافظه کم: ذخیره‌سازی کارآمد برای انواع اولیه.
• معایب:
  • انواع داده محدود: فقط می‌تواند انواع داده ساده سازگار با C را مدیریت کند. نمی‌توانید مستقیماً یک دیکشنری، لیست یا شیء سفارشی پایتون را ذخیره کنید.
  • همگام‌سازی دستی: شما مسئول پیاده‌سازی قفل‌ها برای جلوگیری از شرایط رقابت هستید، که می‌تواند مستعد خطا باشد.
  • غیر منعطف: Array دارای اندازه ثابت است.

روش ۲: نیروگاه منعطف - اشیاء `Manager`

چه اتفاقی می‌افتد اگر نیاز به اشتراک‌گذاری اشیاء پیچیده‌تر پایتون، مانند یک دیکشنری از تنظیمات یا لیستی از نتایج، داشته باشید؟ اینجاست که multiprocessing.Manager می‌درخشد. یک Manager روشی سطح بالا و منعطف را برای اشتراک‌گذاری اشیاء استاندارد پایتون در میان فرآیندها فراهم می‌کند.

نحوه عملکرد اشیاء Manager: مدل فرآیند سرور

برخلاف `Value` و `Array` که از حافظه مشترک مستقیم استفاده می‌کنند، یک `Manager` به شکل متفاوتی عمل می‌کند. هنگامی که یک مدیر را راه‌اندازی می‌کنید، یک فرآیند سرور ویژه را اجرا می‌کند. این فرآیند سرور اشیاء واقعی پایتون (مثلاً دیکشنری واقعی) را در خود جای می‌دهد.

سایر فرآیندهای کاری شما به این شیء دسترسی مستقیم ندارند. در عوض، آنها یک شیء پراکسی ویژه دریافت می‌کنند. هنگامی که یک فرآیند کاری عملیاتی را روی پراکسی انجام می‌دهد (مانند `shared_dict['key'] = 'value'`)، موارد زیر در پشت صحنه اتفاق می‌افتد:

1. فراخوانی متد و آرگومان‌های آن سریالی می‌شوند (pickled).
2. این داده‌های سریالی شده از طریق یک اتصال (مانند یک pipe یا socket) به فرآیند سرور مدیر ارسال می‌شوند.
3. فرآیند سرور داده‌ها را از حالت سریال خارج کرده و عملیات را روی شیء واقعی اجرا می‌کند.
4. اگر عملیات مقداری را برگرداند، آن مقدار سریالی شده و به فرآیند کاری بازگردانده می‌شود.

نکته مهم این است که فرآیند مدیر تمام قفل‌گذاری‌ها و همگام‌سازی‌های لازم را به صورت داخلی مدیریت می‌کند. این امر توسعه را به طور قابل توجهی آسان‌تر و کمتر مستعد خطاهای شرایط رقابت می‌کند، اما به دلیل سربار ارتباط و سریال‌سازی، هزینه‌ای در عملکرد دارد.

اشتراک‌گذاری اشیاء پیچیده: `Manager.dict()` و `Manager.list()`

بیایید مثال شمارنده خود را بازنویسی کنیم، اما این بار از یک `Manager.dict()` برای ذخیره چندین شمارنده استفاده خواهیم کرد.

            
import multiprocessing

def worker(shared_dict, worker_id):
    # Each worker has its own key in the dictionary
    key = f'worker_{worker_id}'
    shared_dict[key] = 0
    for _ in range(1000):
        shared_dict[key] += 1

if __name__ == "__main__":
    with multiprocessing.Manager() as manager:
        # The manager creates a shared dictionary
        shared_data = manager.dict()

        processes = []
        for i in range(5):
            p = multiprocessing.Process(target=worker, args=(shared_data, i))
            processes.append(p)
            p.start()

        for p in processes:
            p.join()

        print(f"Final shared dictionary: {dict(shared_data)}")
        # Expected output might look like:
        # Final shared dictionary: {'worker_0': 1000, 'worker_1': 1000, 'worker_2': 1000, 'worker_3': 1000, 'worker_4': 1000}

            

              
                Copy
              
            
          

نکات کلیدی:

• بدون قفل‌های دستی: به عدم وجود شیء `Lock` توجه کنید. اشیاء پراکسی مدیر، ایمن برای نخ و ایمن برای فرآیند هستند و همگام‌سازی را برای شما مدیریت می‌کنند.
• رابط پایتونیک: می‌توانید با `manager.dict()` و `manager.list()` درست مانند دیکشنری‌ها و لیست‌های معمولی پایتون تعامل داشته باشید.
• انواع پشتیبانی شده: Managerها می‌توانند نسخه‌های مشترکی از `list`، `dict`، `Namespace`، `Lock`، `Event`، `Queue` و موارد دیگر را ایجاد کنند که تطبیق‌پذیری باورنکردنی را ارائه می‌دهد.

مزایا و معایب اشیاء `Manager`

• مزایا:
  • پشتیبانی از اشیاء پیچیده: می‌تواند تقریباً هر شیء استاندارد پایتون را که قابل پیکسل‌سازی است، به اشتراک بگذارد.
  • همگام‌سازی خودکار: قفل‌گذاری را به صورت داخلی مدیریت می‌کند و کد را ساده‌تر و ایمن‌تر می‌سازد.
  • انعطاف‌پذیری بالا: از ساختارهای داده پویا مانند لیست‌ها و دیکشنری‌ها که می‌توانند رشد یا کوچک شوند، پشتیبانی می‌کند.
• معایب:
  • عملکرد پایین‌تر: به دلیل سربار فرآیند سرور، ارتباط بین فرآیندی (IPC) و سریال‌سازی شیء، به طور قابل توجهی کندتر از `Value`/`Array` است.
  • مصرف حافظه بیشتر: خود فرآیند مدیر منابعی را مصرف می‌کند.

جدول مقایسه: `Value`/`Array` در مقابل `Manager`

راهنمایی عملی: چه زمانی از کدام استفاده کنیم؟

انتخاب ابزار مناسب یک معاوضه مهندسی کلاسیک بین عملکرد و راحتی است. در اینجا یک چارچوب تصمیم‌گیری ساده آورده شده است:

شما باید از Value یا Array استفاده کنید وقتی:

• عملکرد اولویت اصلی شماست. شما در حوزه‌ای مانند محاسبات علمی، تحلیل داده یا سیستم‌های بلادرنگ کار می‌کنید که هر میکروثانیه اهمیت دارد.
• داده‌های ساده و عددی را به اشتراک می‌گذارید. این شامل شمارنده‌ها، پرچم‌ها، نشانگرهای وضعیت یا آرایه‌های بزرگ اعداد (به عنوان مثال، برای پردازش با کتابخانه‌هایی مانند NumPy) است.
• با نیاز به همگام‌سازی دستی با استفاده از قفل‌ها یا سایر ابزارهای اولیه، راحت هستید و آن را درک می‌کنید.

شما باید از یک Manager استفاده کنید وقتی:

• سهولت توسعه و خوانایی کد مهم‌تر از سرعت خام است.
• نیاز به اشتراک‌گذاری ساختارهای داده پیچیده یا پویا پایتون مانند دیکشنری‌ها، لیست‌هایی از رشته‌ها یا اشیاء تو در تو دارید.
• داده‌های به اشتراک گذاشته شده با فرکانس بسیار بالا به‌روزرسانی نمی‌شوند، به این معنی که سربار IPC برای حجم کاری برنامه شما قابل قبول است.
• در حال ساخت سیستمی هستید که فرآیندها نیاز به اشتراک‌گذاری یک وضعیت مشترک دارند، مانند یک دیکشنری پیکربندی یا صف نتایج.

نکته‌ای در مورد جایگزین‌ها

در حالی که حافظه مشترک یک مدل قدرتمند است، تنها راه برای ارتباط فرآیندها نیست. ماژول `multiprocessing` مکانیزم‌های انتقال پیام مانند `Queue` و `Pipe` را نیز فراهم می‌کند. به جای اینکه همه فرآیندها به یک شیء داده مشترک دسترسی داشته باشند، پیام‌های مجزا را ارسال و دریافت می‌کنند. این اغلب می‌تواند منجر به طراحی‌های ساده‌تر و کمتر وابسته شود و برای الگوهای تولیدکننده-مصرف‌کننده یا انتقال وظایف بین مراحل یک خط لوله مناسب‌تر باشد.

نتیجه‌گیری

ماژول multiprocessing پایتون یک جعبه ابزار قوی برای ساخت برنامه‌های موازی ارائه می‌دهد. وقتی صحبت از اشتراک‌گذاری داده‌ها می‌شود، انتخاب بین ابزارهای اولیه سطح پایین و انتزاع‌های سطح بالا یک معاوضه اساسی را تعریف می‌کند.

• Value و Array با فراهم کردن دسترسی مستقیم به حافظه مشترک، سرعت بی‌نظیری را ارائه می‌دهند و آنها را به گزینه‌ای ایده‌آل برای برنامه‌های حساس به عملکرد که با انواع داده ساده کار می‌کنند، تبدیل می‌کنند.
• اشیاء Manager انعطاف‌پذیری و سهولت استفاده برتری را با اجازه دادن به اشتراک‌گذاری اشیاء پیچیده پایتون با همگام‌سازی خودکار، به قیمت سربار عملکرد، ارائه می‌دهند.

با درک این تفاوت اصلی، می‌توانید تصمیمی آگاهانه بگیرید و ابزار مناسب را برای ساخت برنامه‌هایی انتخاب کنید که نه تنها سریع و کارآمد، بلکه قوی و قابل نگهداری نیز باشند. کلید اصلی، تحلیل نیازهای خاص شما — نوع داده‌ای که به اشتراک می‌گذارید، فرکانس دسترسی و الزامات عملکردی شما — برای باز کردن قدرت واقعی پردازش موازی در پایتون است.